home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / DClap / DFile.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  10.8 KB  |  545 lines  |  [TEXT/R*ch]
  1. // DFile.cp
  2.  
  3.  
  4. #include <ncbi.h>
  5. #include <dgg.h>
  6. #include "DFile.h"
  7. #include "Dvibrant.h"
  8. #include "DId.h"
  9. #include <stdio.h>
  10.  
  11. #if defined(OS_DOS) || defined(OS_NT)
  12. #include <dir.h>
  13. #include <dos.h>
  14. #endif
  15.  
  16. // class DFileManager
  17. // made into all static methods, Dec94
  18.  
  19. DFileManager*        gFileManager = NULL;
  20.  
  21. const char* DFileManager::kUntitled = "Untitled";
  22.  
  23. char    DFileManager::fName[640];
  24.  
  25. const char* DFileManager::GetInputFileName( const char* extension,  const char* mactype)
  26. {
  27.     Boolean okay= Nlm_GetInputFileName( (char*)fName, 256, (char*)extension, (char*)mactype);
  28.     if (okay) return fName;
  29.     else return NULL;
  30. }
  31.  
  32. const char* DFileManager::GetOutputFileName( const char* defaultname) 
  33. {
  34.     Boolean okay=  Nlm_GetOutputFileName( (char*)fName, 256, (char*)defaultname);
  35.     if (okay) return fName;
  36.     else return NULL;
  37. }
  38.  
  39. const char* DFileManager::GetFolderName()
  40. {
  41.     // this is a quick hack -- currently this selects a file w/in a folder,
  42.     // then chops filename off -- confusing to users, need folder select dialog
  43.     Boolean okay= Nlm_GetInputFileName( (char*)fName, 256, NULL, NULL);
  44.     if (okay) return DFileManager::PathOnlyFromPath(fName);
  45.     else return NULL;
  46. }
  47.     
  48. const char* DFileManager::GetProgramPath()
  49. {
  50.     Nlm_ProgramPath( (char*)fName, 512);
  51.     return fName;
  52. }
  53.  
  54. const char* DFileManager::FilenameFromPath( const char* pathname)
  55. {
  56.     return Nlm_FileNameFind( (char*)pathname);         
  57. }
  58.  
  59. const char* DFileManager::PathOnlyFromPath( const char* pathname)
  60. {
  61.     char* nameonly= Nlm_FileNameFind( (char*)pathname);
  62.     long len= StrLen(pathname) - StrLen(nameonly);
  63.     StrNCpy(fName, pathname, len);
  64.     fName[len]= 0;
  65.     return fName;
  66. }
  67.  
  68.  
  69.  
  70. short DFileManager::FileOrFolderExists( const char* pathname)
  71. {
  72.  
  73. #ifdef OS_MAC
  74.     long    theDirID;
  75.     Boolean isFolder = false;
  76.     char    namebuf[256];
  77.     
  78.     StrNCpy(namebuf, pathname, sizeof(namebuf));
  79.     Nlm_CtoPstr( namebuf);
  80.     short err= GetDirID( 0, 0, namebuf, &theDirID, &isFolder);
  81.     if (err == 0) {
  82.         if (isFolder) return kIsFolder;
  83.         else return kIsFile;
  84.         }
  85.     else return kNothing;
  86. #endif
  87.     
  88. #ifdef OS_UNIX
  89.     struct stat    statbuf;
  90.   if (! stat( pathname, &statbuf)) {
  91.         if ( S_ISDIR(statbuf.st_mode)) return kIsFolder;
  92.         else return kIsFile;
  93.         }
  94.     else return kNothing;
  95. #endif
  96.  
  97. #if defined(OS_DOS) || defined(OS_NT)
  98. #ifdef COMP_SYMC
  99.   FIND* finfo= findfirst( pathname, FA_RDONLY | FA_DIREC);
  100.   if (finfo) {
  101.         if ( finfo->attribute & FA_DIREC) return kIsFolder;
  102.         else return kIsFile;
  103.     }
  104. #else
  105. #if defined(OS_DOS)
  106.     struct  ffblk  finfo;
  107.     
  108.   MemFill( &finfo, 0, sizeof(finfo));
  109.     short err= findfirst( pathname, &finfo, FA_RDONLY | FA_DIREC);
  110.     if (err==0) {
  111.         if ( finfo.ff_attrib & FA_DIREC) return kIsFolder;
  112.         else return kIsFile;
  113.         }
  114.     else return kNothing;
  115. #endif
  116. #endif
  117. #endif
  118.  
  119. // for others...
  120.     return FileExists( pathname);
  121. }
  122.  
  123.  
  124. Boolean DFileManager::FileExists( const char* pathname)
  125. {
  126.     FILE* aFile= Nlm_FileOpen( (char*)pathname, "r");
  127.     if (aFile) {
  128.         Nlm_FileClose( aFile);
  129.         return true;
  130.         }
  131.     else
  132.         return false;
  133. }
  134.  
  135. char*    DFileManager::TempFilename( char* namestore)
  136. {
  137.     return Nlm_TmpNam( namestore);
  138. }
  139.         
  140. Boolean DFileManager::CreateFolder( const char* pathname)
  141. {
  142.     return Nlm_CreateDir( (char*) pathname);
  143. }
  144.  
  145.  
  146.  
  147. const char* DFileManager::BuildPath(const char* rootpath, const char* subfolder, const char* filename)
  148. {
  149.     if (rootpath) StrNCpy(fName, rootpath, 256);
  150.     else fName[0]= 0;
  151.     return Nlm_FileBuildPath(fName, (char*) subfolder, (char*) filename);
  152. }
  153.  
  154.  
  155. void DFileManager::UnixToLocalPath(char*& pathname)
  156. {
  157.     if (!pathname || !*pathname) return;
  158. #ifndef OS_UNIX
  159. #ifdef OS_VMS
  160.     // can't handle this yet .. can stdio calls under vms translate unix/style/paths?
  161. #else
  162. #ifdef OS_MAC
  163.     char buf[512], *np = buf, c;
  164.     char* cp= pathname;
  165.     long  n = 0;
  166.     
  167.     if (*cp == '/') cp++;         // absolute: start at 1st pathname
  168.     else { *np++= DIRDELIMCHR; n++; }     // relative: must insert DIRDEL before start !
  169.     do {
  170.         c= *cp++;
  171.         if (c == '/') c= DIRDELIMCHR;
  172.         *np++ = c; 
  173.         n++;
  174.     } while (c);
  175.     MemCpy(pathname, buf, n); // risky !!
  176.  
  177. #else
  178.     // MDOS, other?
  179.     char* cp= pathname;
  180.     do {
  181.         cp= StrChr( cp, '/');
  182.         if (cp) *cp++= DIRDELIMCHR; 
  183.     } while (cp);
  184. #endif
  185. #endif
  186. #endif
  187. }
  188.  
  189. const char* DFileManager::FileSuffix(const char* pathname)
  190. {
  191.   long     len = StrLen(pathname);
  192.   char* cp = (char*)pathname + len;
  193.   while (cp > pathname && *cp != DIRDELIMCHR) {
  194.         if (*cp == '.') return cp;
  195.         cp--;
  196.       }
  197.   return NULL;
  198. }
  199.  
  200.  
  201. void DFileManager::ReplaceSuffix(char* filename, long maxname, const char* suffix)
  202. {
  203.     long curlen, newlen;
  204.     char* psuf= (char*)FileSuffix(filename);
  205.     if (suffix) newlen= StrLen(suffix) + 1;
  206.   else newlen= 0;
  207.     if (psuf) {
  208.         curlen= StrLen(filename) - StrLen(psuf);
  209.         if (newlen > maxname - curlen) newlen= maxname - curlen;
  210.         if (suffix) StrNCpy( psuf, suffix, newlen);
  211.         else *psuf= 0;
  212.         }
  213.     else if (suffix) {
  214.         curlen= StrLen(filename);
  215.         if (newlen > maxname - curlen) newlen= maxname - curlen;
  216.         if (suffix) StrNCat( filename, suffix, newlen);
  217.         }
  218. }
  219.  
  220.  
  221.  
  222.  
  223.  
  224. //class DFile : public DObject
  225.  
  226.     
  227. DFile::DFile() 
  228. {
  229.     fFile= NULL;
  230.     fName= NULL;
  231.     fMode= StrDup("r");
  232.     fType= NULL;
  233.     fSire= NULL;
  234.     fEof= true;
  235. }
  236.  
  237.     
  238. DFile::DFile(const char* filename, const char* openmode,  
  239.                         const char* type, const char* creator)
  240. {
  241.     fFile= NULL;
  242.     fName= NULL;
  243.     fMode= NULL;
  244.     fType= NULL;
  245.     fSire= NULL;
  246.     fEof= true;
  247.     Initialize( filename, openmode, type, creator);
  248. }
  249.  
  250. void DFile::Initialize(const char* filename, const char* openmode,
  251.                         const char* type, const char* creator)
  252. {
  253.     char* name= StrDup( (char*) filename); // do before free in case these are some of self's data
  254.     char* mode= StrDup( (char*) openmode);
  255.     if (fFile) Close(); 
  256.     if (fName) MemFree(fName);
  257.     if (fMode) MemFree(fMode);
  258.     fName= name;
  259.     fMode= mode;
  260.     fType= (char*)type;
  261.     fSire= (char*)creator;
  262.     fEof= true;
  263. }
  264.     
  265. DFile::~DFile() 
  266. {
  267.     if (fFile) Close();
  268.     MemFree( fName);
  269.     MemFree( fMode);
  270. }
  271.  
  272. Boolean DFile::suicide(void) 
  273. { 
  274.     if (GetOwnerCount() <= 1) { 
  275.         delete this; 
  276.         return true; 
  277.         }
  278.     else 
  279.         return DObject::suicide();
  280. }
  281.  
  282. Boolean DFile::suicide(short ownercount)
  283. {
  284.     if (ownercount < 1) {
  285.         delete this; 
  286.         return true; 
  287.         }
  288.     else 
  289.         return DObject::suicide(ownercount);
  290. }
  291.  
  292. Boolean DFile::Exists()
  293. {
  294. #if 1
  295.     if (fFile) return true; // this is only around if file exists
  296.     else if (!fName) return false;
  297.     else {
  298.         short kind= DFileManager::FileOrFolderExists(fName);
  299.         if (kind == DFileManager::kIsFile) return true;
  300.         else if (kind == DFileManager::kIsFolder) return false; //?? what to do?? false or true?
  301.         else return DFileManager::FileExists(fName); // try another test?
  302.         }
  303. #else
  304.     if (fFile) return true;
  305.     else if (!fName) return false;
  306.     else {
  307.         Boolean exists;
  308.             // !! can't use w/ fOpen mode -- wipes out data if "w" is mode
  309.         if (fMode && *fMode == 'r') {
  310.             fFile= Nlm_FileOpen(fName, fMode);
  311.             exists= (fFile != NULL);
  312.             }
  313.         else {
  314.             fFile= Nlm_FileOpen(fName, "r");
  315.             exists= (fFile != NULL);
  316.             Close();
  317.             }            
  318.         return exists;
  319.         }
  320. #endif
  321. }
  322.  
  323. void DFile::Create(const char* filetype, const char* creator)
  324. {
  325.     // this doesn't delete existing file...! on MacOS
  326.     fType= (char*)filetype;
  327.     fSire= (char*)creator;
  328. #ifndef OS_MAC
  329.  if (! DFileManager::FileExists(fName))
  330. #endif
  331.     Nlm_FileCreate(fName, (char*)filetype, (char*)creator);
  332. }
  333.  
  334. Boolean DFile::Delete()
  335. {
  336.     Close();
  337.     return Nlm_FileRemove(fName);
  338. }
  339.  
  340. Boolean DFile::Rename(const char* newname)
  341. {
  342.     //?? can we leave file open during this?
  343.     Boolean okay= Nlm_FileRename(fName, (char*)newname);
  344.     if (okay) {
  345.         MemFree(fName);
  346.         fName= StrDup(newname);
  347.         }
  348.     return okay;
  349. }
  350.  
  351. void DFile::SetMode(const char* openmode)
  352. {
  353.     if (openmode && StringCmp(openmode, fMode) != 0) {
  354.         Nlm_FileClose( fFile);
  355.         char* mode= StrDup( (char*) openmode);
  356.         MemFree(fMode);
  357.         fMode= mode;
  358.         }
  359. }
  360.  
  361.         // result in all funcs here is error code or 0
  362. short DFile::Open(const char* openmode)
  363. {
  364.     if (openmode) {
  365.         if (StringCmp(openmode, fMode) == 0) 
  366.             openmode= NULL;
  367.         else {
  368.             char* mode= StrDup( (char*) openmode);
  369.             if (fMode) MemFree(fMode);
  370.             fMode= mode;
  371.             }
  372.         }
  373.     if (fFile) 
  374.         if (openmode) {
  375.             Nlm_FileClose( fFile);
  376.             fFile= Nlm_FileOpen(fName, fMode);
  377.             }
  378.         else fseek(fFile, 0, 0); // reset
  379.     else {
  380.         if ((fSire || fType) && (*fMode == 'w' || *fMode == 'a'))
  381.             Create( fType, fSire);
  382.         fFile= Nlm_FileOpen(fName, fMode);
  383.         }
  384.     fEof= (fFile == NULL);
  385.     return (fFile) ? 0 : -1;
  386. }
  387.  
  388.  
  389. short DFile::Close()
  390. {
  391.     if (fFile) Nlm_FileClose( fFile);
  392.     fEof= true;
  393.     fFile= NULL;
  394.     return 0;
  395. }
  396.  
  397. short DFile::GetDataLength(ulong& filelen)
  398. {
  399.     filelen= Nlm_FileLength(fName);
  400.     return 0; // any error code is trapped in Nlm_
  401. }
  402.  
  403. short DFile::GetDataMark(ulong& fileindex)
  404. {
  405.     // not yet available in ncbi toolkit...
  406.     short err= 0;
  407.     fileindex= 0;
  408.     if (!fFile) return -1;
  409.     long findex= ftell(fFile);
  410.     if (findex<0) {
  411.         err= findex;
  412.         fileindex= 0;
  413.         }
  414.     else
  415.         fileindex= findex;
  416.     return err;
  417. }
  418.  
  419. short DFile::SetDataMark(ulong    fileindex)
  420. {
  421.             // not yet available in ncbi toolkit...
  422.     if (!fFile) return -1;
  423.     else return fseek(fFile, fileindex, 0);
  424. }
  425.  
  426.  
  427. Boolean DFile::EndOfFile()
  428. {
  429.     if (!fFile) return -1;
  430.     else {
  431.         if (!fEof) fEof= feof(fFile); // !! need this !! this isn't always RIGHT !!
  432.         return fEof;
  433.         }
  434. }
  435.  
  436. short DFile::GetFileType(long& fileType) 
  437. {
  438.         // this is a silly hack -- needs work?
  439.     if (fMode && strchr(fMode,'t')) fileType= cTEXT;
  440.     else fileType= 0;
  441.     return 0;
  442. }
  443.  
  444. short DFile::ReadData( void* buffer, ulong& count) 
  445. {
  446.     long newcount= Nlm_FileRead(buffer, 1, count, fFile);
  447.     if (newcount == count) return 0;
  448.     else { 
  449.         if (newcount==0) fEof= true;
  450.         count= newcount; 
  451.         return -1; 
  452.         } 
  453. }
  454.  
  455. short DFile::ReadLine( char* line, ulong count) 
  456. {
  457.     void *buf= Nlm_FileGets(line, count, fFile);
  458.     if (buf) return 0;
  459.     else {
  460.         fEof= true;
  461.         return -1;
  462.         }
  463. }
  464.  
  465.  
  466. short DFile::ReadUntil( void* buffer, ulong& count, char stopchar) 
  467. {
  468.                 // no ncbi proc for this...
  469.     register int    c;
  470.     register char* bp = (char*) buffer;
  471.     long maxcount= count;
  472.  
  473.     if (!fFile || !buffer) return -1;
  474.     count= 0;
  475.     while (true) {
  476.         c = fgetc( fFile);
  477.         if (c<0) {
  478.             //if (c == EOF) 
  479.             fEof= true;
  480.             return c;
  481.             }
  482.         else {
  483.             *bp++= c;
  484.             count++;
  485.             if (c == stopchar || count >= maxcount)  
  486.                 return 0; // ?? do we stuff stopchar into buffer?
  487.             }
  488.         }
  489.     return 0;
  490. }
  491.  
  492.  
  493. short DFile::WriteLine( char* line, Boolean addNewline) 
  494. {
  495.     short result;
  496.     result= Nlm_FilePuts( line, fFile);
  497.     if (addNewline) result += Nlm_FilePuts( LineEnd, fFile);
  498.     return result;
  499. }
  500.  
  501. short DFile::WriteData( void* buffer, ulong& count)
  502. {
  503.     ulong newcount= Nlm_FileWrite(buffer, 1, count, fFile);
  504.     if (count != newcount) { count= newcount; return -1; } //??
  505.     else return 0;
  506. }
  507.  
  508.  
  509.  
  510. // class DTempFile
  511.  
  512. DTempFile::DTempFile() : 
  513.     DFile()
  514. {
  515.     // ?? text/binary mode flag
  516.     char    namestore[512];
  517.     Initialize( gFileManager->TempFilename(namestore), "a", NULL, NULL);
  518.     Open();
  519. }
  520.     
  521. DTempFile::~DTempFile()
  522. {
  523.     Delete();
  524. }    
  525.  
  526. char* DTempFile::ReadIntoMemory(ulong& bytesread, Boolean deleteAfterRead)
  527. {
  528.     short     err;
  529.     ulong    count;
  530.     char    * data;
  531.     
  532.     Open("r");
  533.     err= GetDataLength( count);
  534.     data= (char*) MemNew( count+1);
  535.     if (data) {
  536.         err= ReadData( data, count);
  537.         bytesread= count;
  538.         data[count]= 0; // add null term
  539.         }
  540.     Close();
  541.     if (deleteAfterRead) Delete();
  542.     return data;
  543. }
  544.  
  545.